home *** CD-ROM | disk | FTP | other *** search
/ Aminet 21 / Aminet 21 (1997)(GTI - Schatztruhe)[!][Oct 1997].iso / Aminet / gfx / x11 / xmountains.lha / src / calcalt.c < prev    next >
C/C++ Source or Header  |  2003-06-12  |  17KB  |  777 lines
  1. /*
  2.  * Recursive update procedure for fractal landscapes
  3.  *
  4.  * The only procedures needed outside this file are
  5.  *   make_fold, called once to initialise the data structs.
  6.  *   next_strip, each call returns a new strip off the side of the surface
  7.  *                you can keep calling this as often as you want.
  8.  *   free_strip, get rid of the strip when finished with it.
  9.  *   free_fold,  get rid of the data structs when finished with this surface.
  10.  *
  11.  * Apart from make_fold all these routines get their parameters from their
  12.  * local Fold struct, make_fold initialises all these values and has to
  13.  * get it right for the fractal to work. If you want to change the fractal
  14.  * dim in mid run you will have to change values at every level.
  15.  * each recursive level only calls the level below once for every two times it
  16.  * is called itself so it will take a number of iterations for any changes to
  17.  * be notices by the bottom (long length scale) level.
  18.  */
  19. #include <stdio.h>
  20. #include <math.h>
  21. #include "crinkle.h"
  22.  
  23. char calcalt_Id[] = "$Id: calcalt.c,v 2.6 1995/06/12 18:58:04 spb Exp spb $";
  24.  
  25. #ifdef DEBUG
  26. #define DB(A,B) dump_pipeline(A,B)
  27. #else
  28. #define DB(A,B)
  29. #endif
  30.  
  31.  
  32. /*{{{  Strip *make_strip(int level) */
  33. Strip *make_strip (level)
  34. int level;
  35. {
  36.   Strip *p;
  37.   int  points;
  38.  
  39.   p = (Strip *) malloc( sizeof(Strip) );
  40.   if( p == NULL )
  41.   {
  42.     fprintf(stderr,"make_strip: malloc failed\n");
  43.     exit(1);
  44.   }
  45.   p->level = level;
  46.   points = (1 << level) +1;
  47.   p->d = (Height *)malloc( points * sizeof(Height) );
  48.   if( p->d == NULL )
  49.   {
  50.     fprintf(stderr,"make_strip: malloc failed\n");
  51.     exit(1);
  52.   }
  53.   return(p);
  54. }
  55. /*}}}*/
  56. /*{{{  void free_strip(Strip *p) */
  57. void free_strip (p)
  58. Strip *p;
  59. {
  60.   if( p->d )
  61.   {
  62.     free(p->d);
  63.     p->d = NULL;
  64.   }
  65.   free(p);
  66. }
  67. /*}}}*/
  68. /*{{{  Strip *double_strip(Strip s) */
  69. Strip *double_strip (s)
  70. Strip *s;
  71. {
  72.   Strip *p;
  73.   Height *a, *b;
  74.   int i;
  75.  
  76.   p = make_strip((s->level)+1);
  77.   a = s->d;
  78.   b = p->d;
  79.   for(i=0; i < (1<<s->level); i++)
  80.   {
  81.     *b = *a;
  82.     a++;
  83.     b++;
  84.     *b = 0.0;
  85.     b++;
  86.   }
  87.   *b = *a;
  88.   return(p);
  89. }
  90. /*}}}*/
  91. /*{{{  Strip *set_strip(int level, Height value) */
  92. Strip *set_strip (level,value)
  93. int level;
  94. Height value;
  95. {
  96.   int i;
  97.   Strip *s;
  98.   Height *h;
  99.  
  100.   s = make_strip(level);
  101.   h = s->d;
  102.   for( i=0 ; i < ((1<<level)+1) ; i++)
  103.   {
  104.     *h = value;
  105.     h++;
  106.   }
  107.   return(s);
  108. }
  109. /*}}}*/
  110. /*{{{  Fold *make_fold(Parm *param, int levels, int stop, Length len) */
  111. /*
  112.  * Initialise the fold structures.
  113.  * As everything else reads the parameters from their fold
  114.  * structs we need to set these here,
  115.  * p  is the parameter struct common to all update levels.
  116.  * levels is the number of levels of recursion below this one.
  117.  *    Number of points = 2^levels+1
  118.  * stop is the number of levels that are generated as random offsets from a
  119.  *    constant rather than from an average.
  120.  * fractal_start, if true we start in the middle of a mountain range
  121.  *    if false we build up mountains from the start height.
  122.  * length is the length of the side of the square at this level.
  123.  *   N.B this means the update square NOT the width of the fractal.
  124.  *   len gets smaller as the level increases.
  125.  * start, the starting height for a non-fractal start.
  126.  */
  127. Fold *make_fold (param,levels,stop,length)
  128. struct parm *param;
  129. int levels;
  130. int stop;
  131. Length length;
  132. {
  133.   Fold *p;
  134.   Length scale, midscale;
  135.   double root2;
  136.   int i;
  137.  
  138.   if( (levels < stop) || (stop<0) )
  139.   {
  140.     fprintf(stderr,"make_fold: invalid parameters\n");
  141.     fprintf(stderr,"make_fold: levels = %d , stop = %d \n",levels,stop);
  142.     exit(1);
  143.   }
  144.   p = (Fold *)malloc(sizeof(Fold));
  145.   if( p == NULL )
  146.   {
  147.     fprintf(stderr,"make_fold: malloc failed\n");
  148.     exit(1);
  149.   }
  150.   root2=sqrt((double) 2.0 );
  151.   scale = pow((double) length, (double) (2.0 * param->fdim));
  152.   midscale = pow((((double) length)*root2), (double) (2.0 * param->fdim));
  153.   p->level = levels;
  154.   p->stop = stop;
  155.   p->state = START;
  156.   p->save =NULL;
  157.   p->p = param;
  158.   p->scale = scale;
  159.   p->midscale = midscale;
  160.   for(i=0;i<NSTRIP;i++)
  161.   {
  162.     p->s[i] = NULL;
  163.   }
  164.   if( levels > stop )
  165.   {
  166.     p->next = make_fold(param,(levels-1),stop,(2.0*length));
  167.   }else{
  168.     p->next = NULL;
  169.   }
  170.   return( p );
  171. }
  172. /*}}}*/
  173. /*{{{  void free_fold(Fold *f) */
  174. void free_fold (f)
  175. Fold *f;
  176. {
  177.   int i;
  178.   for(i=0;i<NSTRIP;i++)
  179.   {
  180.     if( f->s[i] != NULL )
  181.     {
  182.       free_strip(f->s[i]);
  183.       f->s[i] = NULL;
  184.     }
  185.   }
  186.   free(f);
  187.   return;
  188. }
  189. /*}}}*/
  190.  
  191. /*{{{  Strip *next_strip(Fold *fold) */
  192. Strip *next_strip (fold)
  193. Fold *fold;
  194. {
  195.   Strip *result=NULL;
  196.   Strip *tmp;
  197.   Strip **t;
  198.   int i, count, iter;
  199.  
  200.   count = ((1 << fold->level) +1);
  201.   if( fold->level == fold->stop)
  202.   {
  203.     /*{{{  generate values from scratch */
  204.     result=make_strip(fold->stop);
  205.     for( i=0 ; i < count ; i++)
  206.     {
  207.       result->d[i] = fold->p->mean + (fold->scale * gaussian());
  208.     }
  209.     /*}}}*/
  210.   }else{
  211.   /*
  212.    * There are two types of strip,
  213.    *  A strips - generated by the lower recursion layers.
  214.    *             these contain the corner points and half the side points
  215.    *  B strips - added by this layer, this contains the mid points and
  216.    *             half the side points.
  217.    *
  218.    * The various update routines test for NULL pointer arguments so
  219.    * that this routine will not fail while filling the pipeline.
  220.    */
  221.     while( result == NULL )
  222.     {
  223.       /*{{{iterate*/
  224.       switch(fold->state)
  225.       {
  226.         case START:
  227.           /*{{{  perform an update. return first result*/
  228.           DB("S1",fold);
  229.           t=fold->s;
  230.           /* read in a new A strip at the start of the pipeline */
  231.           tmp =next_strip(fold->next);
  232.           t[0] = double_strip(tmp);
  233.           free_strip(tmp);
  234.           /* make the new B strip */
  235.           t[1]=set_strip(fold->level,0.0);
  236.           if( ! t[2] )
  237.           {
  238.             /* we want to have an A B A pattern of strips at the
  239.              * start of the pipeline.
  240.              * force this when starting the pipe
  241.              */
  242.             t[2]=t[0];
  243.             tmp =next_strip(fold->next);
  244.             t[0] = double_strip(tmp);
  245.             free_strip(tmp);
  246.           }
  247.           DB("E1",fold);
  248.           
  249.           /*
  250.            * create the mid point
  251.            * t := A B A
  252.            */
  253.           DB("S2",fold);
  254.           x_update(count,fold->midscale,0.0,t[0],t[1],t[2]);
  255.           DB("E2",fold);
  256.           
  257.           if(fold->p->rg1)
  258.           {
  259.             DB("S3",fold);
  260.             /*
  261.              * first possible regeneration step
  262.              * use the midpoints to regenerate the corner values
  263.              * increment t by 2 so we still have and A B A pattern
  264.              */
  265.             v_update(count,fold->midscale,fold->p->midmix,t[1],t[2],t[3]);
  266.             t+=2;
  267.             DB("E3",fold);
  268.           
  269.           }
  270.           
  271.           /*
  272.            * fill in the edge points
  273.            * increment t by 2 to preserve the A B A pattern
  274.            */
  275.           DB("S4",fold);
  276.           
  277.           if( fold->p->cross )
  278.           {
  279.             t_update(count,fold->scale,0.0,t[0],t[1],t[2]);
  280.             p_update(count,fold->scale,0.0,t[1],t[2],t[3]);
  281.             t+=2;
  282.           }else{
  283.             hside_update(count,fold->scale,0.0,t[0],t[1],t[2]);
  284.             vside_update(count,fold->scale,0.0,t[2]);
  285.             t+=2;
  286.           }
  287.           DB("E4",fold);
  288.           
  289.           if(fold->p->rg2)
  290.           {
  291.             DB("S5",fold);
  292.             /*
  293.              * second regeneration step update midpoint
  294.              * from the new edge values
  295.              */
  296.             if( fold->p->cross )
  297.             {
  298.               p_update(count,fold->scale,fold->p->mix,t[0],t[1],t[2]);
  299.             }else{
  300.               vside_update(count,fold->scale,fold->p->mix,t[1]);
  301.             }
  302.             DB("E5",fold);
  303.           
  304.           }
  305.           /* increment t by 1
  306.            * this gives a B A B pattern to regen-3
  307.            * if regen 3 is not being used it leaves t pointing to the
  308.            * 2 new result strips
  309.            */
  310.           t++;
  311.           if(fold->p->rg3)
  312.           {
  313.             DB("S6",fold);
  314.           
  315.             /* final regenration step
  316.              * regenerate the corner points from the new edge values
  317.              * this needs a B A B pattern
  318.              * leave t pointing to the 2 new result strips
  319.              *
  320.              * this has to be a t_update
  321.              */
  322.             t_update(count,fold->scale,fold->p->mix,t[0],t[1],t[2]);
  323.             t++;
  324.             DB("E6",fold);
  325.           
  326.           }
  327.           result=t[1];
  328.           fold->save=t[0];
  329.           t[0]=t[1]=NULL;
  330.           fold->state = STORE;
  331.           break;
  332.           /*}}}*/
  333.         case STORE:
  334.           /*{{{  return second value from previous update. */
  335.           result = fold->save;
  336.           fold->save=NULL;
  337.           for(i=NSTRIP-1;i>1;i--)
  338.           {
  339.             fold->s[i] =fold->s[i-2];
  340.           }
  341.           fold->s[0] = fold->s[1]=NULL;
  342.           fold->state = START;
  343.           break;
  344.           /*}}}*/
  345.         default:
  346.           fprintf(stderr,"next_strip: invalid state level %d state %d\n",
  347.                fold->level,fold->state);
  348.           exit(3);
  349.       }
  350.       /*}}}*/
  351.     }
  352.   }
  353.   iter = fold->level - fold->stop;
  354.   if( fold->p->force_front > iter){
  355.    result->d[0] = fold->p->forceval;
  356.   }
  357.   if( fold->p->force_back > iter){
  358.     result->d[count-1] = fold->p->forceval;
  359.   }
  360.   return(result);
  361. }
  362. /*}}}*/
  363.  
  364. /*{{{void x_update(int count,float scale, float mix, Strip *a, Strip *b, Strip *c)*/
  365. void x_update(count, scale, mix, a, b, c)
  366. int count;
  367. float scale;
  368. float mix;
  369. Strip *a;
  370. Strip *b;
  371. Strip *c;
  372. {
  373.   int i;
  374.   float w;
  375.   Height *mp, *lp, *rp;
  376.  
  377.   /* don't run unless we have all the parameters */
  378.   if( !a || !c ) return;
  379.   if( !b )
  380.   {
  381.     fprintf(stderr,"x_update: attempt to update NULL strip\n");
  382.     exit(1);
  383.   }
  384.   
  385.   w = (1.0 - mix)/4.0;
  386.   mp=b->d;
  387.   lp=a->d;
  388.   rp=c->d;
  389.  
  390.   if( mix <= 0.0 ){
  391.     /*{{{random offset to average of new points*/
  392.     for(i=0; i<count-2; i+=2)
  393.     {
  394.       mp[1] = 0.25 * ( lp[0] + rp[0] + lp[2] + rp[2])
  395.             + (scale * gaussian());
  396.       mp+=2;
  397.       lp+=2;
  398.       rp+=2;
  399.     }
  400.     /*}}}*/
  401.   }else if( mix >= 1.0 ){
  402.     /*{{{random offset to old value*/
  403.     for(i=0; i<count-2; i+=2)
  404.     {
  405.       mp[1] = mp[1]
  406.             + (scale * gaussian());
  407.       mp+=2;
  408.       lp+=2;
  409.       rp+=2;
  410.     }
  411.     /*}}}*/
  412.   }else{
  413.     /*{{{mixed update*/
  414.     for(i=0; i<count-2; i+=2)
  415.     {
  416.       mp[1] = (mix * mp[1]) + w * ( lp[0] + rp[0] + lp[2] + rp[2])
  417.             + (scale * gaussian());
  418.       mp+=2;
  419.       lp+=2;
  420.       rp+=2;
  421.     }
  422.     /*}}}*/
  423.   }
  424. }    
  425. /*}}}*/
  426. /*{{{void p_update(int count,float scale, float mix, Strip *a, Strip *b, Strip *c)*/
  427. void p_update(count, scale, mix, a, b, c)
  428. int count;
  429. float scale;
  430. float mix;
  431. Strip *a;
  432. Strip *b;
  433. Strip *c;
  434. {
  435.   int i;
  436.   float w;
  437.   Height *mp, *lp, *rp;
  438.  
  439.   /* don't run if we have no parameters */
  440.   if( !a || !b ) return;
  441.  
  442.   /* if c is missing we can do a vside update instead
  443.    * should really be a sideways t but what the heck we only
  444.    * need this at the start
  445.    */
  446.   if( !c )
  447.   {
  448.     vside_update(count,scale,mix,b);
  449.     return;
  450.   }
  451.  
  452.   w = (1.0 - mix)/4.0;
  453.   mp=b->d;
  454.   lp=a->d;
  455.   rp=c->d;
  456.  
  457.   if( mix <= 0.0 ){
  458.     /*{{{random offset to average of new points*/
  459.     for(i=0; i<count-2; i+=2)
  460.     {
  461.       mp[1] = 0.25 * ( lp[1] + rp[1] + mp[0] + mp[2] )
  462.             + (scale * gaussian());
  463.       mp+=2;
  464.       lp+=2;
  465.       rp+=2;
  466.     }
  467.     /*}}}*/
  468.   }else if(mix >= 1.0){
  469.     /*{{{random offset to old values*/
  470.     for(i=0; i<count-2; i+=2)
  471.     {
  472.       mp[1] = mp[1]
  473.             + (scale * gaussian());
  474.       mp+=2;
  475.       lp+=2;
  476.       rp+=2;
  477.     }
  478.     /*}}}*/
  479.   }else{
  480.     /*{{{mixed update*/
  481.     for(i=0; i<count-2; i+=2)
  482.     {
  483.       mp[1] = (mix * mp[1]) + w * ( lp[1] + rp[1] + mp[0] + mp[2] )
  484.             + (scale * gaussian());
  485.       mp+=2;
  486.       lp+=2;
  487.       rp+=2;
  488.     }
  489.     /*}}}*/
  490.   }
  491. }    
  492.  
  493. /*}}}*/
  494. /*{{{void t_update(int count,float scale, float mix, Strip *a, Strip *b, Strip *c)*/
  495. void t_update(count, scale, mix, a, b, c)
  496. int count;
  497. float scale;
  498. float mix;
  499. Strip *a;
  500. Strip *b;
  501. Strip *c;
  502. {
  503.   int i;
  504.   float w, we;
  505.   Height *mp, *lp, *rp;
  506.  
  507.   /* don't run unless we have all the parameters */
  508.   if( !a || !c ) return;
  509.   if( !b )
  510.   {
  511.     fprintf(stderr,"t_update: attempt to update NULL strip\n");
  512.     exit(1);
  513.   }
  514.  
  515.   w = (1.0 - mix)/4.0;
  516.   we = (1.0 - mix)/3.0;
  517.   mp=b->d;
  518.   lp=a->d;
  519.   rp=c->d;
  520.  
  521.   if( mix <= 0.0){
  522.     /*{{{random offset to average of new points*/
  523.     mp[0] = (1.0/3.0) * ( lp[0] + rp[0] + mp[1] )
  524.             + (scale * gaussian());
  525.     mp++;
  526.     lp++;
  527.     rp++;
  528.     for(i=1; i<count-3; i+=2)
  529.     {
  530.       mp[1] = 0.25 * ( lp[1] + rp[1] + mp[0] + mp[2] )
  531.             + (scale * gaussian());
  532.       mp+=2;
  533.       lp+=2;
  534.       rp+=2;
  535.     }
  536.     mp[1] = (1.0/3.0) * ( lp[1] + rp[1] + mp[0] )
  537.           + (scale * gaussian());
  538.     /*}}}*/
  539.   }else if(mix >= 1.0){
  540.     /*{{{random offset to old values*/
  541.     for(i=0; i<count-2; i+=2)
  542.     {
  543.       mp[0] = mp[0]
  544.             + (scale * gaussian());
  545.       mp+=2;
  546.       lp+=2;
  547.       rp+=2;
  548.     }
  549.     /*}}}*/
  550.   }else{
  551.     /*{{{mixed update*/
  552.     mp[0] = (mix * mp[0]) + we * ( lp[0] + rp[0] + mp[1] )
  553.             + (scale * gaussian());
  554.     mp++;
  555.     lp++;
  556.     rp++;
  557.     for(i=1; i<count-3; i+=2)
  558.     {
  559.       mp[1] = (mix * mp[1]) + w * ( lp[1] + rp[1] + mp[0] + mp[2] )
  560.             + (scale * gaussian());
  561.       mp+=2;
  562.       lp+=2;
  563.       rp+=2;
  564.     }
  565.     mp[1] = (mix * mp[1]) + we * ( lp[1] + rp[1] + mp[0] )
  566.           + (scale * gaussian());
  567.     /*}}}*/
  568.   }
  569. }    
  570.  
  571.  
  572. /*}}}*/
  573. /*{{{void v_update(int count,float scale, float mix, Strip *a, Strip *b, Strip *c)*/
  574. void v_update(count, scale, mix, a, b, c)
  575. int count;
  576. float scale;
  577. float mix;
  578. Strip *a;
  579. Strip *b;
  580. Strip *c;
  581. {
  582.   int i;
  583.   float w, we;
  584.   Height *mp, *lp, *rp;
  585.  
  586.   /* don't run unless we have all the parameters */
  587.   if( !a || !c ) return;
  588.   if( !b )
  589.   {
  590.     fprintf(stderr,"v_update: attempt to update NULL strip\n");
  591.     exit(1);
  592.   }
  593.  
  594.   w = (1.0 - mix)/4.0;
  595.   we = (1.0 - mix)/2.0;
  596.   mp=b->d;
  597.   lp=a->d;
  598.   rp=c->d;
  599.  
  600.   if( mix <= 0.0){
  601.     /*{{{random offset of average of new points*/
  602.     mp[0] = 0.5 * ( lp[1] + rp[1] )
  603.             + (scale * gaussian());
  604.     mp++;
  605.     lp++;
  606.     rp++;
  607.     for(i=1; i<count-3; i+=2)
  608.     {
  609.       mp[1] = 0.25 * ( lp[0] + rp[0] + lp[2] + rp[2] )
  610.             + (scale * gaussian());
  611.       mp+=2;
  612.       lp+=2;
  613.       rp+=2;
  614.     }
  615.     mp[1] = 0.5 * ( lp[0] + rp[0] )
  616.             + (scale * gaussian());
  617.     /*}}}*/
  618.   }else if(mix >= 1.0){
  619.     /*{{{random offset to old values*/
  620.     for(i=0; i<count-2; i+=2)
  621.     {
  622.       mp[0] = mp[0]
  623.             + (scale * gaussian());
  624.       mp+=2;
  625.       lp+=2;
  626.       rp+=2;
  627.     }
  628.     /*}}}*/
  629.   }else{
  630.     /*{{{mixed update*/
  631.     mp[0] = (mix * mp[0]) + we * ( lp[1] + rp[1] )
  632.             + (scale * gaussian());
  633.     mp++;
  634.     lp++;
  635.     rp++;
  636.     for(i=1; i<count-3; i+=2)
  637.     {
  638.       mp[1] = (mix * mp[1]) + w * ( lp[0] + rp[0] + lp[2] + rp[2] )
  639.             + (scale * gaussian());
  640.       mp+=2;
  641.       lp+=2;
  642.       rp+=2;
  643.     }
  644.     mp[1] = (mix * mp[1]) + we * ( lp[0] + rp[0] )
  645.             + (scale * gaussian());
  646.     /*}}}*/
  647.   }
  648. }    
  649.  
  650. /*}}}*/
  651. /*{{{void vside_update(int count,float scale, float mix, Strip *a)*/
  652. void vside_update(count, scale, mix, a)
  653. int count;
  654. float scale;
  655. float mix;
  656. Strip *a;
  657. {
  658.   int i;
  659.   float w;
  660.   Height *mp;
  661.  
  662.   /* don't run unless we have all the parameters */
  663.   if( !a ) return;
  664.  
  665.  
  666.   w = (1.0 - mix)/2.0;
  667.   mp=a->d;
  668.  
  669.   if( mix <= 0.0){
  670.     /*{{{random offset to average of new points*/
  671.     for(i=0; i<count-2; i+=2)
  672.     {
  673.       mp[1] = 0.5 * ( mp[0] + mp[2] )
  674.             + (scale * gaussian());
  675.       mp+=2;
  676.     }
  677.     /*}}}*/
  678.   }else if(mix >= 1.0){
  679.     /*{{{random offset to old values*/
  680.     for(i=0; i<count-2; i+=2)
  681.     {
  682.       mp[1] = mp[1]
  683.             + (scale * gaussian());
  684.       mp+=2;
  685.     }
  686.     /*}}}*/
  687.   }else{
  688.     /*{{{mixed update*/
  689.     for(i=0; i<count-2; i+=2)
  690.     {
  691.       mp[1] = (mix * mp[1]) + w * ( mp[0] + mp[2] )
  692.             + (scale * gaussian());
  693.       mp+=2;
  694.     }
  695.     /*}}}*/
  696.   }
  697. }    
  698.  
  699.  
  700. /*}}}*/
  701. /*{{{void hside_update(int count,float scale, float mix, Strip *a, Strip *b, Strip *c)*/
  702. void hside_update(count, scale, mix, a, b, c)
  703. int count;
  704. float scale;
  705. float mix;
  706. Strip *a;
  707. Strip *b;
  708. Strip *c;
  709. {
  710.   int i;
  711.   float w;
  712.   Height *mp, *lp, *rp;
  713.  
  714.   /* don't run unless we have all the parameters */
  715.   if( !a || !c ) return;
  716.   if( !b )
  717.   {
  718.     fprintf(stderr,"x_update: attempt to update NULL strip\n");
  719.     exit(1);
  720.   }
  721.  
  722.   w = (1.0 - mix)/2.0;
  723.   mp=b->d;
  724.   lp=a->d;
  725.   rp=c->d;
  726.  
  727.   if( mix <= 0.0 ){
  728.     /*{{{random offset to average of new points*/
  729.     for(i=0; i<count; i+=2)
  730.     {
  731.       mp[0] = 0.5 * ( lp[0] + rp[0] )
  732.             + (scale * gaussian());
  733.       mp+=2;
  734.       lp+=2;
  735.       rp+=2;
  736.     }
  737.     /*}}}*/
  738.   }else if(mix >= 1.0){
  739.     /*{{{random offset to old points*/
  740.     for(i=0; i<count; i+=2)
  741.     {
  742.       mp[0] = mp[0]
  743.             + (scale * gaussian());
  744.       mp+=2;
  745.       lp+=2;
  746.       rp+=2;
  747.     }
  748.     /*}}}*/
  749.   }else{
  750.     /*{{{mixed update*/
  751.     for(i=0; i<count; i+=2)
  752.     {
  753.       mp[0] = (mix * mp[0]) + w * ( lp[0] + rp[0] )
  754.             + (scale * gaussian());
  755.       mp+=2;
  756.       lp+=2;
  757.       rp+=2;
  758.     }
  759.     /*}}}*/
  760.   }
  761. }    
  762.  
  763.  
  764.  
  765. /*}}}*/
  766.  
  767.  
  768. #ifdef DEBUG
  769. dump_pipeline(s, f)
  770. char *s;
  771. Fold *f;
  772. {
  773.   printf("%s[%d]: %0xd %0xd %0xd %0xd %0xd %0xd %0xd %0xd\n",s,f->level,
  774.      f->s[0],f->s[1],f->s[2],f->s[3],f->s[4],f->s[5],f->s[6],f->s[7]);
  775. }  
  776. #endif
  777.